package com.ai.dmc.utils.export.excelhelper;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import net.sf.json.JSONException;
import net.sf.json.JSONObject;

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFDataFormat;
import org.apache.poi.hssf.usermodel.HSSFFont;
import org.apache.poi.hssf.usermodel.HSSFRichTextString;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.hssf.util.Region;


public class POIExcelHelper {
	public static Logger logger = Logger.getLogger(POIExcelHelper.class);
	private static final String OS = System.getProperty("os.name");   

	/**
	 * 向指定的行中插入单元格
	 * @param row：目标行（即：将要向其插入单元格的行）
	 * @param id：单元格的位置（即：在行中属于第几个单元格，序号从0开始）
	 * @param value：单元格的值
	 * @param style：单元格的样式
	 */
	public static void createCell(HSSFRow row, int id, String value,
			HSSFCellStyle style) {
		HSSFCell cell = row.createCell((short) id);
		if (value == null) {
			value = "";
		}
		Pattern p = Pattern.compile("^\\d+(\\.\\d+)?$");
		Matcher matcher = p.matcher(value);
		if(matcher.matches()){
			// 是数字当作double处理
			cell.setCellValue(Double.parseDouble(value));
		}else {
			cell.setCellType(HSSFCell.CELL_TYPE_STRING);
			cell.setCellValue(new HSSFRichTextString(value));
		}
		if (style != null) {
			cell.setCellStyle(style);
		}
	}
	
	/**
	 * 向指定的行中插入单元格（添加数字格式化方法	2011-08-16 by xufc5）
	 * @param row：目标行（即：将要向其插入单元格的行）
	 * @param id：单元格的位置（即：在行中属于第几个单元格，序号从0开始）
	 * @param value：单元格的值
	 * @param style：单元格的样式
	 * @param colFmt: 单元格格式化类型
	 * @param styleNumber: 数字格式单元格风格
	 */
	public static void createCell(HSSFRow row, int id, String value,
			HSSFCellStyle style,String colFmt,HSSFCellStyle styleNumber) {
		HSSFCell cell = row.createCell((short) id);
		if (value == null) {
			value = "";
		}
		if("number".equals(colFmt)&&styleNumber!=null){
			cell.setCellStyle(styleNumber);
		}else if (style != null) {
			cell.setCellStyle(style);
		}
		Pattern p = Pattern.compile("^\\d+(\\.\\d+)?$");
		Matcher matcher = p.matcher(value);
		if(matcher.matches()){
			// 是数字当作double处理
			if("number".equals(colFmt)){
				cell.setCellValue(Double.parseDouble(value));
			}else{
				cell.setCellValue(new HSSFRichTextString(value));
			}
		}else {
			// 是数字当作double处理
			if("number".equals(colFmt)){
				// 如果设置数字出错，则将单元格再设为文本
				try{
					cell.setCellValue(Double.parseDouble(value.replaceAll(",", "")));
				}catch(Exception e){
					cell.setCellType(HSSFCell.CELL_TYPE_STRING);
					cell.setCellValue(new HSSFRichTextString(value));
				}
			}else{
				cell.setCellType(HSSFCell.CELL_TYPE_STRING);
				cell.setCellValue(new HSSFRichTextString(value));
			}
		}
	}
	
	/**
	 * 创建表头，这里只是最简单的表头，即单行没有合并单元格的情况
	 * @param sheet
	 * @param style
	 * @param selExportColumns
	 */
	public static void parseTitle(HSSFSheet sheet, HSSFCellStyle style,
			String[] selExportColumns) {
		HSSFRow titlerow = sheet.createRow((short) 0);

		for (int i = 0; i < selExportColumns.length; i++) {
			createCell(titlerow, i, selExportColumns[i], style);
		}
	}
	
	/**
	 * 创建带合并单元格的表头
	 * @param sheet
	 * @param style
	 * @param headerList
	 */
	public static void parseTitle(HSSFSheet sheet, HSSFCellStyle style, List<CellBean> headerList){
		if(headerList==null){
			return;
		}
		for(int i=0; i<headerList.size(); i++){
			CellBean cellBean = headerList.get(i);
			createUnitCell(sheet,style,cellBean);
		}
	}
	
	/**
	 * 创建具有合并单元的单元格
	 * @param sheet
	 * @param style
	 * @param cellBean
	 */
	private static void createUnitCell(HSSFSheet sheet, HSSFCellStyle style, CellBean cellBean){
		int rowindex = cellBean.getRowindex();
		int colindex = cellBean.getColindex();
		
		//huangc modify 201004 避免创建行时覆盖信息
//		HSSFRow titlerow = sheet.createRow((short)rowindex);
		HSSFRow titlerow = sheet.getRow(rowindex);
		if(titlerow==null){
			titlerow=sheet.createRow((short)rowindex);
		}
		//end
		
		createCell(titlerow, colindex, cellBean.getValue(), style);
		
		Region region = new Region(rowindex,(short)colindex, rowindex+cellBean.getRowlength()-1, (short)(colindex+cellBean.getCollength()-1));
		sheet.addMergedRegion(region);
		setRegionStyle(sheet,region,style);
		
//		CellRangeAddress range=new CellRangeAddress(rowindex,rowindex+cellBean.getRowlength()-1,colindex,colindex+cellBean.getCollength()-1);
//		sheet.addMergedRegion(range);
	}
	
	/**
	 * 将数据放入Excel表格中
	 * 这里数据的组织方式是以HashMap的方式组织的，其中key为表头相同的值，value即为该表头中要填充的值
	 * 此方法的优点是：可以将所有的值先存入HashMap中，在输出时动态的选定输出哪些项,
	 * 同时列的顺序调整不需要重新组织数据，完全按照selExportColumns的顺序，数据自动调整
	 * 该方法可以有效避免由于数据组织不当，引起的表头与内容列不对应的情况
	 * 该方法的缺点是：需要以HashMap方式组织数据，增加工作量，且多耗内存
	 * @param dataset: 所有记录组成的队列，其中每条记录即为一个HashMap，HashMap方式为<表头,对应的值>
	 * @param sheet: 目标excel表单
	 * @param style：单元行的样式，这里不能单独指定每行的样式
	 * @param selExportColumns：要输出的表头
	 */
	public static void parseDataByHM(HSSFSheet sheet, Collection<Map<String,String>> dataset, 
			HSSFCellStyle style, String[] selExportColumns){
		parseDataByHM(sheet,dataset,style,selExportColumns,1);
	}
	
	/**
	 * 将数据放入Excel表格中
	 * 这里数据的组织方式是以HashMap的方式组织的，其中key为表头相同的值，value即为该表头中要填充的值
	 * 此方法的优点是：可以将所有的值先存入HashMap中，在输出时动态的选定输出哪些项,
	 * 同时列的顺序调整不需要重新组织数据，完全按照selExportColumns的顺序，数据自动调整
	 * 该方法可以有效避免由于数据组织不当，引起的表头与内容列不对应的情况
	 * 该方法的缺点是：需要以HashMap方式组织数据，增加工作量，且多耗内存
	 * @param dataset: 所有记录组成的队列，其中每条记录即为一个HashMap，HashMap方式为<表头,对应的值>
	 * @param sheet: 目标excel表单
	 * @param style：单元行的样式，这里不能单独指定每行的样式
	 * @param selExportColumns：要输出的表头
	 */
	public static void parseDataByHM(HSSFSheet sheet, Collection<Map<String,String>> dataset, 
			HSSFCellStyle style, String[] selExportColumns, int headerRowSize){
		if(selExportColumns == null){
			parseDataByHM(sheet,dataset,style);
		}else {
			Iterator<Map<String,String>> itera = dataset.iterator();
			int index = headerRowSize;
			while(itera.hasNext()) {
				Map<String,String> hm = itera.next();
				HSSFRow row = sheet.createRow(index);
				Iterator<String> iter = hm.keySet().iterator();
				int j = 0;
				while(iter.hasNext()){
					String value = String.valueOf(hm.get(iter.next()));
					POIExcelHelper.createCell(row, j, value,style);
					j++;
				}
				//for (int j = 0; j < selExportColumns.length; j++) {
				//	POIExcelHelper.createCell(row, j, String.valueOf(hm.get(selExportColumns[j])), style);
				//}
				index++ ;
			}
		}
	}
	
	/**
	 * 将数据放入Excel表格中
	 * 这里数据的组织方式是以HashMap的方式组织的，其中key为表头相同的值，value即为该表头中要填充的值
	 * 此方法的优点是：可以将所有的值先存入HashMap中，在输出时动态的选定输出哪些项,
	 * 同时列的顺序调整不需要重新组织数据，完全按照selExportColumns的顺序，数据自动调整
	 * 该方法可以有效避免由于数据组织不当，引起的表头与内容列不对应的情况
	 * 该方法的缺点是：需要以HashMap方式组织数据，增加工作量，且多耗内存
	 * @param dataset: 所有记录组成的队列，其中每条记录即为一个HashMap，HashMap方式为<表头,对应的值>
	 * @param sheet: 目标excel表单
	 * @param style：单元行的样式，这里不能单独指定每行的样式
	 * @param selExportColumns：要输出的表头
	 * @param colFmt: 单元格格式化类型
	 */
	public static void parseDataByHM(HSSFSheet sheet, Collection<Map<String,String>> dataset, 
			HSSFCellStyle style, String[] selExportColumns, int headerRowSize,String colFmt,HSSFWorkbook workbook){
		if(StringUtils.isEmpty(colFmt)){
			POIExcelHelper.parseDataByHM(sheet, dataset, style,selExportColumns,headerRowSize);
		}else if(selExportColumns == null){
			parseDataByHM(sheet,dataset,style,colFmt,workbook);
		}else {
			//处理单元格格式化方式    start
			Iterator<Map<String,String>> iteraFmt = dataset.iterator();
			String[] colFmts = null;
			HSSFCellStyle styleNumber = null;
			String pattern = null; 
			Map<Integer,HSSFCellStyle> styleMap = new LinkedHashMap<Integer,HSSFCellStyle>();
			try {
				JSONObject obj = JSONObject.fromObject(colFmt.toLowerCase());
				if(iteraFmt.hasNext()){
					Map <String,String> map = iteraFmt.next();
					if(map!=null&&map.keySet().size()>0){
						colFmts = new String[map.keySet().size()];
						int k = 0;
						for(String key:map.keySet()){
							net.sf.json.JSONObject objson = (net.sf.json.JSONObject) obj.get(key.toLowerCase());
							colFmts[k]=objson.getString("dt");
							pattern = objson.getString("pt"); 
							if("number".equals(colFmts[k])){
								styleNumber = getDefaultNumberStyle(workbook);
								if(pattern!=null&&!"".equals(pattern)){
									styleNumber.setDataFormat(workbook.createDataFormat().getFormat(pattern));
								}
								styleMap.put(k, styleNumber);
							}
							k++;
						}
					}
				}
			} catch (JSONException e) {
				logger.error("excel单元格格式化类型封装出错: " + e.getStackTrace(),e);
			}
			//处理单元格格式化方式    end
			Iterator<Map<String,String>> itera = dataset.iterator();
			int index = headerRowSize;
			while(itera.hasNext()) {
				Map<String,String> hm = itera.next();
				HSSFRow row = sheet.createRow(index);
				Iterator<String> iter = hm.keySet().iterator();
				int j = 0;
				while(iter.hasNext()){
					String value = String.valueOf(hm.get(iter.next()));
					POIExcelHelper.createCell(row, j, value,style,colFmts[j],styleMap.get(j) );
					j++;
				}
				index++ ;
			}
		}
	}
	
	/**
	 * 该方法是对所有的已组织成HashMap的数据都输出，不在进行有选择的输出
	 * 注意：此方法将会将列的顺序打乱，将不会按照预期的顺序进行显示，仅应用于对列的顺序没有要求的情况
	 * @param dataset
	 * @param sheet
	 * @param style
	 */
	public static void parseDataByHM(HSSFSheet sheet, Collection<Map<String,String>> dataset, 
			HSSFCellStyle style){
		Iterator<Map<String,String>> itera = dataset.iterator();
		int index = 0;
		while(itera.hasNext()) {
			Map<String,String> hm = itera.next();
			HSSFRow row = sheet.createRow((int) index + 1);
			Iterator<String> iter = hm.keySet().iterator();
			int j =0;
			while(iter.hasNext()){
				String value = String.valueOf(hm.get(iter.next()));
				POIExcelHelper.createCell(row, j, value,style);
				j++;
			}
			index++ ;
		}
	}	
	/**
	 * 该方法是对所有的已组织成HashMap的数据都输出，不在进行有选择的输出
	 * 方法添加单元格格式化参数
	 * 注意：此方法将会将列的顺序打乱，将不会按照预期的顺序进行显示，仅应用于对列的顺序没有要求的情况
	 * @param dataset
	 * @param sheet
	 * @param style
	 * @param colFmt 单元格格式化类型
	 */
	public static void parseDataByHM(HSSFSheet sheet, Collection<Map<String,String>> dataset, 
			HSSFCellStyle style,String colFmt,HSSFWorkbook workbook){
		//处理单元格格式化方式    start
		Iterator<Map<String,String>> iteraFmt = dataset.iterator();
		String[] colFmts = null;
		HSSFCellStyle styleNumber = null;
		String pattern = null; 
		Map<Integer,HSSFCellStyle> styleMap = new LinkedHashMap<Integer,HSSFCellStyle>();
		try {
			JSONObject obj = JSONObject.fromObject(colFmt.toLowerCase());
			if(iteraFmt.hasNext()){
				Map <String,String> map = iteraFmt.next();
				if(map!=null&&map.keySet().size()>0){
					colFmts = new String[map.keySet().size()];
					int k = 0;
					for(String key:map.keySet()){
						net.sf.json.JSONObject objson = (net.sf.json.JSONObject) obj.get(key.toLowerCase());
						colFmts[k]=objson.getString("dt");
						pattern = objson.getString("pt"); 
						if("number".equals(colFmts[k])){
							styleNumber = getDefaultNumberStyle(workbook);
							if(pattern!=null&&!"".equals(pattern)){
								styleNumber.setDataFormat(workbook.createDataFormat().getFormat(pattern));
							}
							styleMap.put(k, styleNumber);
						}
						k++;
					}
				}
			}
		} catch (JSONException e) {
			logger.error("excel单元格格式化类型封装出错: " + e.getStackTrace(),e);
		}
		//处理单元格格式化方式    end
		Iterator<Map<String,String>> itera = dataset.iterator();
		int index = 0;
		while(itera.hasNext()) {
			Map<String,String> hm = itera.next();
			HSSFRow row = sheet.createRow((int) index + 1);
			Iterator<String> iter = hm.keySet().iterator();
			int j =0;
			while(iter.hasNext()){
				String value = String.valueOf(hm.get(iter.next()));
				POIExcelHelper.createCell(row, j, value,style,colFmts[j],styleMap.get(j));
				j++;
			}
			index++ ;
		}
	}
	
	/**
	 * 将数据放入Excel表格中
	 * 这里数据的组织方式是，直接将要输出的数据安装与表头相同的顺序存入List的中
	 * 该方法优点：组织方便，省内存
	 * 该方法缺点：如果数据组织顺序出现问题，可能会造成数据列与表头不统一
	 * @param dataset
	 * @param sheet
	 * @param style
	 */
	public static void parseDataByL(HSSFSheet sheet, Collection<List<String>> dataset, 
			HSSFCellStyle style){
		parseDataByL(sheet,dataset,1,style);
	}
	
	/**
	 * 将数据放入Excel表格中
	 * 这里数据的组织方式是，直接将要输出的数据安装与表头相同的顺序存入List的中
	 * 该方法优点：组织方便，省内存
	 * 该方法缺点：如果数据组织顺序出现问题，可能会造成数据列与表头不统一
	 * @param sheet
	 * @param dataset
	 * @param headerRowSize: 表头所占的行数
	 * @param style：表体样式
	 */
	public static void parseDataByL(HSSFSheet sheet, Collection<List<String>> dataset, int headerRowSize,
			HSSFCellStyle style){
		Iterator<List<String>> itera = dataset.iterator();
		int index = headerRowSize;
		while(itera.hasNext()){
			List<String> tempList = itera.next();
			HSSFRow row = sheet.createRow(index);
			for(int j=0; j<tempList.size(); j++){
				String value = tempList.get(j);
				POIExcelHelper.createCell(row, j, value,style);
			}
			index++ ;
		}
	}
	
	public static HSSFCellStyle getDefaultStyle(HSSFWorkbook workbook) {
		//定义字体属性
		HSSFFont font = workbook.createFont();
		//设置字体颜色
		font.setColor(HSSFColor.BLUE.index);
		//设置字体高度
		font.setFontHeight((short) 200);
		//设置字体类型
		font.setFontName("Arial");
		//font.setFontName("楷体_GB2312");
		//设置字体粗细
		font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);

		HSSFCellStyle style = workbook.createCellStyle();
		//设置对齐方式
		style.setAlignment(HSSFCellStyle.VERTICAL_CENTER);
		style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
		style.setFont(font);
		//设置背景色
		style.setFillForegroundColor(HSSFColor.GREY_25_PERCENT.index);
		style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
		style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
	    style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
	    style.setBorderRight(HSSFCellStyle.BORDER_THIN);
	    style.setBorderTop(HSSFCellStyle.BORDER_THIN);

		return style;
	}

	public static HSSFCellStyle getDefaultFootStyle(HSSFWorkbook workbook) {
		HSSFFont font = workbook.createFont();
		font.setColor(HSSFColor.BLACK.index);
		font.setFontHeight((short) 200);
		font.setFontName("Arial");
		//font.setFontName("楷体_GB2312");
		font.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
		HSSFDataFormat format = workbook.createDataFormat();
		HSSFCellStyle style = workbook.createCellStyle();
		style.setDataFormat(format.getFormat("@"));
		style.setAlignment(HSSFCellStyle.VERTICAL_CENTER);
		style.setAlignment(HSSFCellStyle.ALIGN_LEFT);
		style.setFont(font);
		style.setFillForegroundColor(HSSFColor.WHITE.index);
		style.setFillPattern(HSSFCellStyle.NO_FILL);
		style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
	    style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
	    style.setBorderRight(HSSFCellStyle.BORDER_THIN);
	    style.setBorderTop(HSSFCellStyle.BORDER_THIN);
		return style;
	}
	
	/**
	 * 2011-08-17 by xufc5
	 * 数值型单元格风格
	 * @param workbook
	 * @return
	 */
	public static HSSFCellStyle getDefaultNumberStyle(HSSFWorkbook workbook) {
		HSSFFont font = workbook.createFont();
		font.setColor(HSSFColor.BLACK.index);
		font.setFontHeight((short) 200);
		font.setFontName("Arial");
		//font.setFontName("楷体_GB2312");
		font.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);

		HSSFCellStyle style = workbook.createCellStyle();
		style.setAlignment(HSSFCellStyle.VERTICAL_CENTER);
		style.setAlignment(HSSFCellStyle.ALIGN_LEFT);
		style.setFont(font);
		style.setFillForegroundColor(HSSFColor.WHITE.index);
		style.setFillPattern(HSSFCellStyle.NO_FILL);
		style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
	    style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
	    style.setBorderRight(HSSFCellStyle.BORDER_THIN);
	    style.setBorderTop(HSSFCellStyle.BORDER_THIN);
		return style;
	}

	/**
	 * 将生成的excel文件保存
	 * @param workbook
	 * @param dir
	 * @param filename
	 * @throws IOException
	 */
	public static void save(HSSFWorkbook workbook, String dir, String filename)
			throws IOException {
		dir = dir == null ? "" : dir;
		if (dir != null && !dir.equals("")) {
			if (!dir.endsWith("\\"))
				dir += "\\";
		}
		logger.debug("out put dir: " + dir);
		File outdir = new File(dir);
		if (!outdir.exists()) {
			outdir.mkdirs();
		}
		FileOutputStream fOut = new FileOutputStream(dir + filename);
		workbook.write(fOut);
		fOut.flush();
		fOut.close();
		logger.info(dir + filename + " generated!");
	}
	/**
	 * 如果isEncode=true，则文件名由UTF-8转为系统编码格式
	 * @param workbook
	 * @param dir
	 * @param filename
	 * @param isEncode 是否将文件名由UTF-8转为系统编码格式
	 * @throws IOException
	 */
	public static void save(HSSFWorkbook workbook, String dir, String filename,boolean isEncode)
			throws IOException {
		dir = dir == null ? "" : dir;
		if (dir != null && !dir.equals("")) {
			if (!dir.endsWith("\\"))
				dir += "\\";
		}
		logger.debug("out put dir: " + dir);
		File outdir = new File(dir);
		if (!outdir.exists()) {
			outdir.mkdirs();
		}

		FileOutputStream fOut = new FileOutputStream(dir + filename);
		workbook.write(fOut);
		fOut.flush();
		fOut.close();
		logger.info(dir + filename + " generated!");
	}
	/**
	 * 用生成的excel文件构造输出流
	 * @param workbook
	 * @param dir
	 * @param filename
	 * @throws IOException
	 */
	public static OutputStream saveToStream(HSSFWorkbook workbook, String dir, String filename) throws IOException {
		dir = dir == null ? "" : dir;
		if (dir != null && !dir.equals("")) {
			if (!dir.endsWith("\\"))
				dir += "\\";
		}
		logger.debug("out put dir: " + dir);
		File outdir = new File(dir);
		if (!outdir.exists()) {
			outdir.mkdirs();
		}
		FileOutputStream fOut = new FileOutputStream(dir + filename);
		workbook.write(fOut);
		fOut.flush();
		return fOut;
	}
	
	// 合并单元格后，设置合并后的边框
	private static void setRegionStyle(HSSFSheet sheet, Region region,
			HSSFCellStyle cs) {
		for (int i = region.getRowFrom(); i <= region.getRowTo(); i++) {
			HSSFRow row = sheet.getRow(i);
			if(row == null){
				row = sheet.createRow(i);
			}
			for (int j = region.getColumnFrom(); j <= region.getColumnTo(); j++) {
				HSSFCell cell = row.getCell((short) j);
				if(cell == null){
					cell = row.createCell((short)j);
				}
				cell.setCellStyle(cs);
			}
		}
	}
	
	public static void main(String[] args) throws IOException{
		HSSFWorkbook workbook = new HSSFWorkbook();
		HSSFSheet sheet = workbook.createSheet("sheetName");
		HSSFRow titlerow = sheet.createRow((short) 0);
		createCell(titlerow, 0, "表头1", getDefaultStyle(workbook));
		Region r1 = new Region(0,(short)0,1,(short)0);
		sheet.addMergedRegion(r1);
		setRegionStyle(sheet,r1,getDefaultStyle(workbook));
		createCell(titlerow,1,"表头2",getDefaultStyle(workbook));
		Region r2 = new Region(0,(short)1,0,(short)2);
		sheet.addMergedRegion(r2);
		setRegionStyle(sheet,r2,getDefaultStyle(workbook));
		createCell(titlerow, 3, "表头3",getDefaultStyle(workbook));
		Region r3 = new Region(0,(short)3,1,(short)3);
		sheet.addMergedRegion(r3);
		setRegionStyle(sheet,r3,getDefaultStyle(workbook));
		titlerow = sheet.createRow((short)1);
		//createCell(titlerow,0,"",getDefaultStyle(workbook));
		createCell(titlerow,1,"表头2.1",getDefaultStyle(workbook));
		createCell(titlerow,2,"表头2.2",getDefaultStyle(workbook));
		String dirPath = System.getProperty("user.home") + "\\TEMPEXCELFILE";
		save(workbook,dirPath,"1.xls");
		
		CellBean cellBean1 = new CellBean();
		cellBean1.setRowindex(0);
		cellBean1.setColindex(0);
		cellBean1.setRowlength(2);
		cellBean1.setCollength(1);
		cellBean1.setValue("表头1");
		
		CellBean cellBean2 = new CellBean();
		cellBean2.setRowindex(0);
		cellBean2.setColindex(1);
		cellBean2.setRowlength(1);
		cellBean2.setCollength(3);
		cellBean2.setValue("表头2");
		
		CellBean cellBean21 = new CellBean();
		cellBean21.setRowindex(1);
		cellBean21.setColindex(1);
		cellBean21.setRowlength(1);
		cellBean21.setCollength(1);
		cellBean21.setValue("表头2.1");
		
		CellBean cellBean22 = new CellBean();
		cellBean22.setRowindex(1);
		cellBean22.setColindex(2);
		cellBean22.setRowlength(1);
		cellBean22.setCollength(1);
		cellBean22.setValue("表头2.2");
		
		CellBean cellBean23 = new CellBean();
		cellBean23.setRowindex(1);
		cellBean23.setColindex(3);
		cellBean23.setRowlength(1);
		cellBean23.setCollength(1);
		cellBean23.setValue("表头2.3");
		
		CellBean cellBean3 = new CellBean();
		cellBean3.setRowindex(0);
		cellBean3.setColindex(4);
		cellBean3.setRowlength(2);
		cellBean3.setCollength(1);
		cellBean3.setValue("表头3");
		
		List<CellBean> cellBeanList = new ArrayList<CellBean>();
		cellBeanList.add(cellBean1);
		cellBeanList.add(cellBean2);
		cellBeanList.add(cellBean21);
		cellBeanList.add(cellBean22);
		cellBeanList.add(cellBean23);
		cellBeanList.add(cellBean3);
		
		HSSFWorkbook workbook2 = new HSSFWorkbook();
		HSSFSheet sheet2 = workbook2.createSheet("sheetName");
		parseTitle(sheet2,getDefaultStyle(workbook2),cellBeanList);
		save(workbook2,dirPath,"合并.xls");
	}
}
